{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"center\">\n",
    "    <img src=\"https://github.com/GeostatsGuy/GeostatsPy/blob/master/TCG_color_logo.png?raw=true\" width=\"220\" height=\"240\" />\n",
    "\n",
    "</p>\n",
    "\n",
    "## Subsurface Data Analytics \n",
    "\n",
    "## Artificial Neural Networks for Prediction in Python\n",
    "\n",
    "#### Michael Pyrcz, Associate Professor, University of Texas at Austin \n",
    "\n",
    "##### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1) | [GeostatsPy](https://github.com/GeostatsGuy/GeostatsPy)\n",
    "\n",
    "#### Honggeun Jo, Graduate Student, The University of Texas at Austin\n",
    "\n",
    "##### [LinkedIn](https://www.linkedin.com/in/honggeun-jo/?originalSubdomain=kr) | [Twitter](https://twitter.com/HonggeunJ)\n",
    "\n",
    "### PGE 383 Exercise: Artificial Neural Networks for Subsurface Modeling in Python \n",
    "\n",
    "Here's a simple workflow, demonstration of artificial neural networks for subsurface modeling workflows. This should help you get started with building subsurface models that use data analytics and machine learning. Here's some basic details about neural networks.  \n",
    "\n",
    "#### Neural Networks\n",
    "\n",
    "Machine learning method for supervised learning for classification and regression analysis.  Here are some key aspects of support vector machines.\n",
    "\n",
    "**Basic Design** *\"...a computing system made up of a number of simple, highly interconnected processing elements, which process information by their dynamic state response to external inputs.\"* Caudill (1989). \n",
    "\n",
    "**Nature-inspire Computing** based on the neuronal structure in the brain, including many interconnected simple, processing units, known as nodes that are capable of complicated emergent pattern detection due to a large number of nodes and interconnectivity.\n",
    "\n",
    "**Training and Testing** just like and other predictive model (e.g. linear regression, decision trees and support vector machines) we perform training to fit parameters and testing to tune hyperparameters.  Here we observe the error with training and testing datasets, but do not demonstrate tuning of the hyperparameters.  \n",
    "\n",
    "**Parameters** are the weights applied to each connection and a bias term applied to each node.  For a single node in an artificial neural network, this includes the slope terms, $\\beta_i$, and the bias term, $\\beta_{0}$.\n",
    "\n",
    "\\begin{equation}\n",
    "Y = \\sum_{i=1}^m \\beta_i X + \\beta_0\n",
    "\\end{equation}\n",
    "\n",
    "it can be seen that the number of parameters increases rapidly as we increase the number of nodes and the connectivity between the nodes.\n",
    "\n",
    "**Layers** the typical artificial neural net is structured with an **input layer**, with one node for each $m$ predictor feature, $X_1,\\ldots,X_m$. There is an **ouput layer**, with one node for each $r$ response feature, $Y_1,\\ldots,Y_r$.  There may be one or more layers of nodes between the input and output layers, known as **hidden layer(s)**.  \n",
    "\n",
    "**Connections** are the linkages between the nodes in adjacent layers.  For example, in a fully connected artificial neural network, all the input nodes are connected to all of the nodes in the first layer, then all of the nodes in the first layer are connected to the next layer and so forth. Each connection includes a weight parameter as indicated above.\n",
    "\n",
    "**Nodes** receive the weighted signal from the connected previous layer nodes, sum and then apply this result to the **activation** function in the node. Some example activation functions include:\n",
    "\n",
    "* **Binary** the node fires or not.  This is represented by a Heaviside step function.\n",
    "\n",
    "* **Identify** the input is passed to the output $f(x) = x$\n",
    "\n",
    "* **Linear** the node passes a signal that increases linearly with the weighted input.\n",
    "\n",
    "* **Logistic** also known as sigmoid or soft step $f(x) = \\frac{1}{1+e^{-x}}$\n",
    "\n",
    "the node output is the nonlinear activiation function applied to the linearly weighted inputs. This is fed to all nodes in the next layer.\n",
    "\n",
    "**Training Cycles** - the presentation of a batch of data, forward application of the current prediction model to make estimates, calculation of error and then backpropagation of error to correct the artificial neural network parameters to reduce the error over all of the batches.\n",
    "\n",
    "**Batch** is the set of training data for each training cycle of forward prediction and back propagation of error, drawn to train for each iteration. There is a trade-off, a larger batch results in more computational time per iteration, but a more accurate estimate of the error to adjust the weights.  Smaller batches result in a nosier estimate of the error, but faster epochs, this results in faster learning and even possibly more robust models.\n",
    "\n",
    "**Epochs** - is a set of training cycles, batches covering all available training data.  \n",
    "\n",
    "**Local Minimums** - if one calculated the error hypersurface over the range of model parameters it would be hyparabolic, there is a global minimium error solution.  But this error hyper surface is rough and it is possible to be stuck in a local minimum. **Learning Rate** and **Mommentum** coefficients are introduced to avoid getting stuck in local minimums.\n",
    "\n",
    "* **Mommentum** is a hyperparameter to control the use of information from the weight update over the last epoch for consideration in the current epoch.  This can be accomplished with an update vector, $v_i$, a mommentum parameter, $\\alpha$, to calculate the current weight update, $v_{i+1}$ given the new update $\\theta_{i+1}$.\n",
    "\n",
    "\\begin{equation}\n",
    "v_{i+1} = \\alpha v_i + \\theta_{i+1}\n",
    "\\end{equation}\n",
    "\n",
    "* **Learning Rate** is a hyperparameter that controls the adjustment of the weights in response to the gradient indicated by backpropagation of error \n",
    "\n",
    "##### Applications to subsurface modeling\n",
    "\n",
    "We demonstrate the estimation of normal score transformed porosity from depth.  This would be useful for building a vertical trend model. \n",
    "\n",
    "* modeling the complicated relationship between porosity and depth.\n",
    "\n",
    "#### Limitations of Neural Network Estimation\n",
    "\n",
    "Since we demonstrate the use of an artificial neural network to estimate porosity from sparsely sampled data over depth, we should comment on limitations of our artificial neural networks for this estimation problem:\n",
    "\n",
    "* does not honor the well data\n",
    "\n",
    "* does not honor the histogram of the data\n",
    "\n",
    "* does not honor spatial correlation \n",
    "\n",
    "* does not honor the multivariate relationship\n",
    "\n",
    "* generally low interpretability models\n",
    "\n",
    "* requires a large number of data for effective training\n",
    "\n",
    "* high model complexity with high model variance\n",
    "\n",
    "\n",
    "#### Workflow Goals\n",
    "\n",
    "Learn the basics of machine learning in python to predict subsurface features. This includes:\n",
    "\n",
    "* Loading and visualizing sample data\n",
    "* Trying out neural nets\n",
    "\n",
    "#### Objective \n",
    "\n",
    "In the PGE 383: Subsurface Machine Learning Class, I want to provide hands-on experience with building subsurface modeling workflows. Python provides an excellent vehicle to accomplish this. I have coded a package called GeostatsPy with GSLIB: Geostatistical Library (Deutsch and Journel, 1998) functionality that provides basic building blocks for building subsurface modeling workflows. \n",
    "\n",
    "The objective is to remove the hurdles of subsurface modeling workflow construction by providing building blocks and sufficient examples. This is not a coding class per se, but we need the ability to 'script' workflows working with numerical methods.    \n",
    "\n",
    "#### Getting Started\n",
    "\n",
    "Here's the steps to get setup in Python with the GeostatsPy package:\n",
    "\n",
    "1. Install Anaconda 3 on your machine (https://www.anaconda.com/download/). \n",
    "2. From Anaconda Navigator (within Anaconda3 group), go to the environment tab, click on base (root) green arrow and open a terminal. \n",
    "3. In the terminal type: pip install geostatspy. \n",
    "4. Open Jupyter and in the top block get started by copy and pasting the code block below from this Jupyter Notebook to start using the geostatspy functionality. \n",
    "\n",
    "You will need to copy the data file to your working directory.  They are available here:\n",
    "\n",
    "* Tabular data - 12_sample_data.csv found [here](https://github.com/GeostatsGuy/GeoDataSets/blob/master/12_sample_data.csv).\n",
    "\n",
    "There are exampled below with these functions. You can go here to see a list of the available functions, https://git.io/fh4eX, other example workflows and source code. \n",
    "\n",
    "#### Import Required Packages\n",
    "\n",
    "We will also need some standard packages. These should have been installed with Anaconda 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np                        # ndarrys for gridded data\n",
    "import pandas as pd                       # DataFrames for tabular data\n",
    "import os                                 # set working directory, run executables\n",
    "import matplotlib.pyplot as plt           # for plotting\n",
    "import seaborn as sns                     # for plotting\n",
    "import warnings                           # supress warnings from seaborn pairplot\n",
    "from sklearn.model_selection import train_test_split # train / test DatFrame split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also need the following packages to train and test our artificial neural nets:\n",
    "\n",
    "* Tensorflow - open source machine learning, with Keras modulw - high level application programing interface (API) to build and train models\n",
    "\n",
    "More information is available at [tensorflow install](https://www.tensorflow.org/install).\n",
    "\n",
    "* This workflow was designed with tensorflow version > 2.0.\n",
    "\n",
    "To import Tensorflow, set memory growth and check your current version of tensorflow you could run the next block of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow version = 2.9.0\n",
      "Num GPUs Available:  1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[name: \"/device:CPU:0\"\n",
       " device_type: \"CPU\"\n",
       " memory_limit: 268435456\n",
       " locality {\n",
       " }\n",
       " incarnation: 12242209797338969813\n",
       " xla_global_id: -1,\n",
       " name: \"/device:GPU:0\"\n",
       " device_type: \"GPU\"\n",
       " memory_limit: 2156161024\n",
       " locality {\n",
       "   bus_id: 1\n",
       "   links {\n",
       "   }\n",
       " }\n",
       " incarnation: 9436720257703148078\n",
       " physical_device_desc: \"device: 0, name: GeForce RTX 2080 SUPER, pci bus id: 0000:01:00.0, compute capability: 7.5\"\n",
       " xla_global_id: 416903419]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.python.client import device_lib\n",
    "\n",
    "physical_devices = tf.config.list_physical_devices('GPU')\n",
    "\n",
    "tf.config.experimental.set_memory_growth(physical_devices[0], True)\n",
    "print('TensorFlow version = ' + tf.__version__)                         # check the installed version of tensorflow\n",
    "\n",
    "print(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))\n",
    "device_lib.list_local_devices()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's import all of the tensorflow and keras methods that we will need in our workflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential  \n",
    "from tensorflow.keras.layers import Dense, Activation, Dropout  \n",
    "#from keras.models import Sequential, load_model\n",
    "#from keras.layers.core import Dense, Dropout, Activation\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.python.keras import backend as k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set the working directory\n",
    "\n",
    "I always like to do this so I don't lose files and to simplify subsequent read and writes (avoid including the full address each time). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#os.chdir(\"c:/PGE383\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading Data\n",
    "Let's load the provided multivariate, spatial dataset '12_sample_data.csv'.  It is a comma delimited file with: \n",
    "\n",
    "* Depth ($m$)\n",
    "* Normal Score Porosity \n",
    "\n",
    "It is common to transform properties to standard normal for geostatistical workflows.\n",
    "\n",
    "We load it with the pandas 'read_csv' function into a data frame we called 'df' and then preview it to make sure it loaded correctly.\n",
    "\n",
    "**Python Tip: using functions from a package** just type the label for the package that we declared at the beginning:\n",
    "\n",
    "```python\n",
    "import pandas as pd\n",
    "```\n",
    "\n",
    "so we can access the pandas function 'read_csv' with the command: \n",
    "\n",
    "```python\n",
    "pd.read_csv()\n",
    "```\n",
    "\n",
    "but read csv has required input parameters. The essential one is the name of the file. For our circumstance all the other default parameters are fine. If you want to see all the possible parameters for this function, just go to the docs [here](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html).  \n",
    "\n",
    "* The docs are always helpful\n",
    "* There is often a lot of flexibility for Python functions, possible through using various inputs parameters\n",
    "\n",
    "also, the program has an output, a pandas DataFrame loaded from the data.  So we have to specficy the name / variable representing that new object.\n",
    "\n",
    "```python\n",
    "df = pd.read_csv(\"1D_Porosity.csv\")  \n",
    "```\n",
    "\n",
    "Let's run this command to load the data and then look at the resulting DataFrame to ensure that we loaded it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Depth</th>\n",
       "      <th>Nporosity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.25</td>\n",
       "      <td>-1.37</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.50</td>\n",
       "      <td>-2.08</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.75</td>\n",
       "      <td>-1.67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.00</td>\n",
       "      <td>-1.16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.25</td>\n",
       "      <td>-0.24</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Depth  Nporosity\n",
       "0   0.25      -1.37\n",
       "1   0.50      -2.08\n",
       "2   0.75      -1.67\n",
       "3   1.00      -1.16\n",
       "4   1.25      -0.24"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#df2 = pd.read_csv(\"1D_Porosity.csv\")                    # read a .csv file in as a DataFrame  \n",
    "df2 = pd.read_csv(\"https://raw.githubusercontent.com/GeostatsGuy/GeoDataSets/master/1D_Porosity.csv\") # load the data from Dr. Pyrcz's github repository\n",
    "df2.head()                                              # we could also use this command for a table preview "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Normalization\n",
    "\n",
    "We must normalize the features before we apply them in an artificial neural network model. These are the motivations for this normalization:\n",
    "\n",
    "* remove impact of scale of different types of data (i.e., depth varies between $[0,10]$, but porosity only varies between $[-3,3.0]$).\n",
    "\n",
    "* activation functions in artificial neural networks are designed to be more sensive to values of nodes closer to 0.0 (i.e., results in higher gradient and improves backpropagation in training)\n",
    "\n",
    "Let's normalize each feature.  \n",
    "\n",
    "* We apply the min max normalization by-hand to force both the predictor and response features to be bound $[-1,1]$.\n",
    "\n",
    "* It is easy to backtransform given we keep track of the original min and max values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Depth</th>\n",
       "      <th>Nporosity</th>\n",
       "      <th>norm_Depth</th>\n",
       "      <th>norm_Nporosity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.25</td>\n",
       "      <td>-1.37</td>\n",
       "      <td>-1.000000</td>\n",
       "      <td>-0.679458</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.50</td>\n",
       "      <td>-2.08</td>\n",
       "      <td>-0.948718</td>\n",
       "      <td>-1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.75</td>\n",
       "      <td>-1.67</td>\n",
       "      <td>-0.897436</td>\n",
       "      <td>-0.814898</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.00</td>\n",
       "      <td>-1.16</td>\n",
       "      <td>-0.846154</td>\n",
       "      <td>-0.584650</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.25</td>\n",
       "      <td>-0.24</td>\n",
       "      <td>-0.794872</td>\n",
       "      <td>-0.169300</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Depth  Nporosity  norm_Depth  norm_Nporosity\n",
       "0   0.25      -1.37   -1.000000       -0.679458\n",
       "1   0.50      -2.08   -0.948718       -1.000000\n",
       "2   0.75      -1.67   -0.897436       -0.814898\n",
       "3   1.00      -1.16   -0.846154       -0.584650\n",
       "4   1.25      -0.24   -0.794872       -0.169300"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "depth_min = df2['Depth'].values.min(); depth_max = df2['Depth'].values.max()\n",
    "Npor_min = df2['Nporosity'].values.min(); Npor_max = df2['Nporosity'].values.max()\n",
    "df2['norm_Depth'] = (df2['Depth'] - depth_min)/(depth_max - depth_min) * 2 - 1\n",
    "df2['norm_Nporosity'] = (df2['Nporosity'] - Npor_min)/(Npor_max - Npor_min) * 2 - 1\n",
    "df2.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also a good idea to check the summary statistics.  \n",
    "\n",
    "* All normalized features should now range from -1.0 to 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Depth</th>\n",
       "      <td>40.0</td>\n",
       "      <td>5.125000</td>\n",
       "      <td>2.922613</td>\n",
       "      <td>0.25</td>\n",
       "      <td>2.687500</td>\n",
       "      <td>5.125000e+00</td>\n",
       "      <td>7.562500</td>\n",
       "      <td>10.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nporosity</th>\n",
       "      <td>40.0</td>\n",
       "      <td>0.022250</td>\n",
       "      <td>0.992111</td>\n",
       "      <td>-2.08</td>\n",
       "      <td>-0.757500</td>\n",
       "      <td>1.400000e-01</td>\n",
       "      <td>0.742500</td>\n",
       "      <td>2.35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>norm_Depth</th>\n",
       "      <td>40.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.599510</td>\n",
       "      <td>-1.00</td>\n",
       "      <td>-0.500000</td>\n",
       "      <td>-5.551115e-17</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>norm_Nporosity</th>\n",
       "      <td>40.0</td>\n",
       "      <td>-0.050903</td>\n",
       "      <td>0.447906</td>\n",
       "      <td>-1.00</td>\n",
       "      <td>-0.402935</td>\n",
       "      <td>2.257336e-03</td>\n",
       "      <td>0.274266</td>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                count      mean       std   min       25%           50%  \\\n",
       "Depth            40.0  5.125000  2.922613  0.25  2.687500  5.125000e+00   \n",
       "Nporosity        40.0  0.022250  0.992111 -2.08 -0.757500  1.400000e-01   \n",
       "norm_Depth       40.0  0.000000  0.599510 -1.00 -0.500000 -5.551115e-17   \n",
       "norm_Nporosity   40.0 -0.050903  0.447906 -1.00 -0.402935  2.257336e-03   \n",
       "\n",
       "                     75%    max  \n",
       "Depth           7.562500  10.00  \n",
       "Nporosity       0.742500   2.35  \n",
       "norm_Depth      0.500000   1.00  \n",
       "norm_Nporosity  0.274266   1.00  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.describe().transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Separation of Training and Testing Data\n",
    "\n",
    "We also need to split our data into training / testing datasets so that we:\n",
    "\n",
    "* can train our artificial neural networks using the training data \n",
    "\n",
    "* while testing their performance with the withheld testing (validation) data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "X2 = df2.iloc[:,[0,2]]                        # extract the predictor feature - acoustic impedance\n",
    "y2 = df2.iloc[:,[1,3]]                        # extract the response feature - porosity\n",
    "X2_train, X2_test, y2_train, y2_test = train_test_split(X2, y2, test_size=0.2, random_state=73073)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Depth</th>\n",
       "      <th>norm_Depth</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>7.75</td>\n",
       "      <td>0.538462</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>2.50</td>\n",
       "      <td>-0.538462</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>4.25</td>\n",
       "      <td>-0.179487</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>3.50</td>\n",
       "      <td>-0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.00</td>\n",
       "      <td>-0.846154</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Depth  norm_Depth\n",
       "30   7.75    0.538462\n",
       "9    2.50   -0.538462\n",
       "16   4.25   -0.179487\n",
       "13   3.50   -0.333333\n",
       "3    1.00   -0.846154"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X2_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualize the Dataset\n",
    "\n",
    "Let's visualize the train and test data split on a single scatter plot.\n",
    "\n",
    "* we want to make sure it is fair\n",
    "\n",
    "* ensure that the test samples are not clustered or too far away from the training data.\n",
    "\n",
    "We will look at the original data and normalized data, the input to the neural network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(211)\n",
    "plt.plot(X2_train['Depth'].values,y2_train['Nporosity'].values, 'o', markerfacecolor='red', markeredgecolor='black', alpha=0.4, label = \"Train\")\n",
    "plt.plot(X2_test['Depth'].values,y2_test['Nporosity'].values, 'o', markerfacecolor='blue', markeredgecolor='black', alpha=0.4, label = \"Test\")\n",
    "plt.title('Standard Normal Porosity vs. Depth')\n",
    "plt.xlabel('Z (m)')\n",
    "plt.ylabel('NPorosity')\n",
    "plt.legend()\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=1.0, wspace=0.2, hspace=0.2)\n",
    "\n",
    "plt.subplot(212)\n",
    "plt.plot(X2_train['norm_Depth'].values,y2_train['norm_Nporosity'].values, 'o', markerfacecolor='red', markeredgecolor='black', alpha=0.4, label = \"Train\")\n",
    "plt.plot(X2_test['norm_Depth'].values,y2_test['norm_Nporosity'].values, 'o', markerfacecolor='blue', markeredgecolor='black', alpha=0.4, label = \"Test\")\n",
    "plt.title('Normalized Standard Normal Porosity vs. Normalized Depth')\n",
    "plt.xlabel('Normalized Z')\n",
    "plt.ylabel('Normalized NPorosity')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=1.5, wspace=0.2, hspace=0.3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Specify the Prediction Locations\n",
    "\n",
    "Given this training and testing data, let's specify the prediction locations over the range of the observed depths at regularly spaced $nbins$ locations.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify the prediction locations\n",
    "nbins = 1000\n",
    "depth_bins = np.linspace(depth_min, depth_max, nbins) # set the bins for prediction\n",
    "norm_depth_bins = (depth_bins-depth_min)/(depth_max-depth_min)*2-1 # use normalized bins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build and Train a Simple Neural Network\n",
    "\n",
    "For our first model we will build a simple model with:  \n",
    "\n",
    "* 1 predictor feature - depth ($d$)\n",
    "\n",
    "* 1 responce feature - normal score porosity ($N\\{\\phi\\}$)\n",
    "\n",
    "we will build a model to predict normal score porosity from depth over all locations in our model $\\bf{u} \\in AOI$. \n",
    "\n",
    "\\begin{equation}\n",
    "N\\{\\phi(\\bf{u})\\} = \\hat{f} (d(\\bf{u}))\n",
    "\\end{equation}\n",
    "\n",
    "and use this model to support the prediction of porosity between the wells.\n",
    "\n",
    "#### Design, Train and Test a Neural Network\n",
    "\n",
    "In the following code we use keras / tensorflow to:\n",
    "\n",
    "1. **Design the Network** - we use a fully connected, feed forward neural network with one node in the input and output layers, to receive the normalized depth and output the normalized (normal score) porosity.  We found by trial and error, given the complexity of the dataset, that we required a significant network width (about 500 nodes) and a network depth of atleast 4 hidden layers. \n",
    "\n",
    "\n",
    "2. **Select the Optimizer** - we selected the adam optimizer (Kingma and Ba, 2015).  This optimizer is computationally efficient and is well suited to problems with noisy data and sparse gradients. It is an extension of stochastic gradient descent with the addition of adaptive gradient algorithm that calculates per-parameter learning rates to improve learning with sparse gradients, and root mean square propopagation that sets the learning rate based on the recent magnitudes of the gradients for each parameter to improve performance with noisy data.  We include stochastic gradient descent for experimentation. \n",
    "\n",
    "    * we found a learning rate of 0.01 to 0.001 works well\n",
    "    * we found the rate of decay parameters of $\\beta_1=0.9$ and $\\beta_2=0.999$ performed well\n",
    "    \n",
    "\n",
    "3. **Compile the Machine** - specify the optimizer, loss function and the metric for model training. \n",
    "\n",
    "\n",
    "4. **Train the Network** - fit / train the model parameters over a specified number of batch size within a specified number of epochs.  We specify the train and test normalized predictor and response features.\n",
    "\n",
    "Then we visualize the model in the original units."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "InternalError",
     "evalue": "Graph execution error:\n\nDetected at node 'sequential/dense/MatMul' defined at (most recent call last):\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\runpy.py\", line 197, in _run_module_as_main\n      return _run_code(code, main_globals, None,\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\runpy.py\", line 87, in _run_code\n      exec(code, run_globals)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel_launcher.py\", line 17, in <module>\n      app.launch_new_instance()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\traitlets\\config\\application.py\", line 982, in launch_instance\n      app.start()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelapp.py\", line 712, in start\n      self.io_loop.start()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\tornado\\platform\\asyncio.py\", line 215, in start\n      self.asyncio_loop.run_forever()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\asyncio\\base_events.py\", line 596, in run_forever\n      self._run_once()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\asyncio\\base_events.py\", line 1890, in _run_once\n      handle._run()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\asyncio\\events.py\", line 80, in _run\n      self._context.run(self._callback, *self._args)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 510, in dispatch_queue\n      await self.process_one()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 499, in process_one\n      await dispatch(*args)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 406, in dispatch_shell\n      await result\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 730, in execute_request\n      reply_content = await reply_content\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 383, in do_execute\n      res = shell.run_cell(\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\zmqshell.py\", line 528, in run_cell\n      return super().run_cell(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2940, in run_cell\n      result = self._run_cell(\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2995, in _run_cell\n      return runner(coro)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\async_helpers.py\", line 129, in _pseudo_sync_runner\n      coro.send(None)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3194, in run_cell_async\n      has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3373, in run_ast_nodes\n      if await self.run_code(code, result, async_=asy):\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3433, in run_code\n      exec(code_obj, self.user_global_ns, self.user_ns)\n    File \"C:\\Users\\17137\\AppData\\Local\\Temp\\ipykernel_12560\\3213448179.py\", line 22, in <module>\n      hist_2 = model_2.fit(X2_train['norm_Depth'], y2_train['norm_Nporosity'],\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 1409, in fit\n      tmp_logs = self.train_function(iterator)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 1051, in train_function\n      return step_function(self, iterator)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 1040, in step_function\n      outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 1030, in run_step\n      outputs = model.train_step(data)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 889, in train_step\n      y_pred = self(x, training=True)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 490, in __call__\n      return super().__call__(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\sequential.py\", line 374, in call\n      return super(Sequential, self).call(inputs, training=training, mask=mask)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\functional.py\", line 458, in call\n      return self._run_internal_graph(\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\functional.py\", line 596, in _run_internal_graph\n      outputs = node.layer(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\layers\\core\\dense.py\", line 221, in call\n      outputs = tf.matmul(a=inputs, b=self.kernel)\nNode: 'sequential/dense/MatMul'\nAttempting to perform BLAS operation using StreamExecutor without BLAS support\n\t [[{{node sequential/dense/MatMul}}]] [Op:__inference_train_function_678]",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mInternalError\u001b[0m                             Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [12], line 22\u001b[0m\n\u001b[0;32m     19\u001b[0m model_2\u001b[38;5;241m.\u001b[39mcompile(optimizer\u001b[38;5;241m=\u001b[39madam,loss\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmse\u001b[39m\u001b[38;5;124m'\u001b[39m,metrics\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maccuracy\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[0;32m     21\u001b[0m \u001b[38;5;66;03m# Train the Network\u001b[39;00m\n\u001b[1;32m---> 22\u001b[0m hist_2 \u001b[38;5;241m=\u001b[39m \u001b[43mmodel_2\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX2_train\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mnorm_Depth\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my2_train\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mnorm_Nporosity\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m     23\u001b[0m \u001b[43m    \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2000\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m     24\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mX2_test\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mnorm_Depth\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my2_test\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mnorm_Nporosity\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m     26\u001b[0m \u001b[38;5;66;03m# Predict with the Network\u001b[39;00m\n\u001b[0;32m     27\u001b[0m pred_norm_Nporsity \u001b[38;5;241m=\u001b[39m model_2\u001b[38;5;241m.\u001b[39mpredict(np\u001b[38;5;241m.\u001b[39marray(norm_depth_bins)) \u001b[38;5;66;03m# predict with our ANN\u001b[39;00m\n",
      "File \u001b[1;32m~\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py:67\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     65\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:  \u001b[38;5;66;03m# pylint: disable=broad-except\u001b[39;00m\n\u001b[0;32m     66\u001b[0m   filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m---> 67\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28mNone\u001b[39m\n\u001b[0;32m     68\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[0;32m     69\u001b[0m   \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n",
      "File \u001b[1;32m~\\anaconda3\\envs\\tf\\lib\\site-packages\\tensorflow\\python\\eager\\execute.py:54\u001b[0m, in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m     52\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m     53\u001b[0m   ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[1;32m---> 54\u001b[0m   tensors \u001b[38;5;241m=\u001b[39m pywrap_tfe\u001b[38;5;241m.\u001b[39mTFE_Py_Execute(ctx\u001b[38;5;241m.\u001b[39m_handle, device_name, op_name,\n\u001b[0;32m     55\u001b[0m                                       inputs, attrs, num_outputs)\n\u001b[0;32m     56\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m     57\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
      "\u001b[1;31mInternalError\u001b[0m: Graph execution error:\n\nDetected at node 'sequential/dense/MatMul' defined at (most recent call last):\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\runpy.py\", line 197, in _run_module_as_main\n      return _run_code(code, main_globals, None,\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\runpy.py\", line 87, in _run_code\n      exec(code, run_globals)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel_launcher.py\", line 17, in <module>\n      app.launch_new_instance()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\traitlets\\config\\application.py\", line 982, in launch_instance\n      app.start()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelapp.py\", line 712, in start\n      self.io_loop.start()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\tornado\\platform\\asyncio.py\", line 215, in start\n      self.asyncio_loop.run_forever()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\asyncio\\base_events.py\", line 596, in run_forever\n      self._run_once()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\asyncio\\base_events.py\", line 1890, in _run_once\n      handle._run()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\asyncio\\events.py\", line 80, in _run\n      self._context.run(self._callback, *self._args)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 510, in dispatch_queue\n      await self.process_one()\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 499, in process_one\n      await dispatch(*args)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 406, in dispatch_shell\n      await result\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 730, in execute_request\n      reply_content = await reply_content\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 383, in do_execute\n      res = shell.run_cell(\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\ipykernel\\zmqshell.py\", line 528, in run_cell\n      return super().run_cell(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2940, in run_cell\n      result = self._run_cell(\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2995, in _run_cell\n      return runner(coro)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\async_helpers.py\", line 129, in _pseudo_sync_runner\n      coro.send(None)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3194, in run_cell_async\n      has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3373, in run_ast_nodes\n      if await self.run_code(code, result, async_=asy):\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3433, in run_code\n      exec(code_obj, self.user_global_ns, self.user_ns)\n    File \"C:\\Users\\17137\\AppData\\Local\\Temp\\ipykernel_12560\\3213448179.py\", line 22, in <module>\n      hist_2 = model_2.fit(X2_train['norm_Depth'], y2_train['norm_Nporosity'],\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 1409, in fit\n      tmp_logs = self.train_function(iterator)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 1051, in train_function\n      return step_function(self, iterator)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 1040, in step_function\n      outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 1030, in run_step\n      outputs = model.train_step(data)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 889, in train_step\n      y_pred = self(x, training=True)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\training.py\", line 490, in __call__\n      return super().__call__(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\sequential.py\", line 374, in call\n      return super(Sequential, self).call(inputs, training=training, mask=mask)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\functional.py\", line 458, in call\n      return self._run_internal_graph(\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\functional.py\", line 596, in _run_internal_graph\n      outputs = node.layer(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\layers\\core\\dense.py\", line 221, in call\n      outputs = tf.matmul(a=inputs, b=self.kernel)\nNode: 'sequential/dense/MatMul'\nAttempting to perform BLAS operation using StreamExecutor without BLAS support\n\t [[{{node sequential/dense/MatMul}}]] [Op:__inference_train_function_678]"
     ]
    }
   ],
   "source": [
    "# Design the neural network\n",
    "model_2 = Sequential([\n",
    "    Dense(100, activation='linear', input_shape=(1,)),                  # input layer\n",
    "    Dense(50, activation='relu'),\n",
    "#     Dense(50, activation='relu'),\n",
    "#     Dense(50, activation='relu'), \n",
    "#     Dense(20, activation='relu'),                                    # uncomment these to add hidden layers\n",
    "#     Dense(20, activation='relu'),\n",
    "#     Dense(20, activation='relu'),\n",
    "#     Dense(20, activation='relu'),\n",
    "    Dense(1, activation='linear'),                                     # output layer\n",
    "])\n",
    "\n",
    "# Select the Optimizer\n",
    "adam = Adam(learning_rate=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) # adam optimizer\n",
    "#sgd = keras.optimizers.SGD(lr=0.001, momentum=0.0, decay = 0.0, nesterov=False)  # stochastic gradient descent\n",
    "\n",
    "# Compile the Machine\n",
    "model_2.compile(optimizer=adam,loss='mse',metrics=['accuracy'])\n",
    "\n",
    "# Train the Network\n",
    "hist_2 = model_2.fit(X2_train['norm_Depth'], y2_train['norm_Nporosity'],\n",
    "    batch_size=5, epochs=2000,\n",
    "    validation_data=(X2_test['norm_Depth'], y2_test['norm_Nporosity']),verbose = 0)\n",
    "\n",
    "# Predict with the Network\n",
    "pred_norm_Nporsity = model_2.predict(np.array(norm_depth_bins)) # predict with our ANN\n",
    "pred_Nporosity = ((pred_norm_Nporsity + 1)/2*(Npor_max - Npor_min)+Npor_min)\n",
    "\n",
    "# Plot the Model Predictions\n",
    "plt.subplot(1,1,1)\n",
    "plt.plot(depth_bins,pred_Nporosity,'black',linewidth=2)\n",
    "plt.plot(X2_train['Depth'].values,y2_train['Nporosity'].values, 'o', markerfacecolor='red', markeredgecolor='black', alpha=1.0, label = \"Train\")\n",
    "plt.plot(X2_test['Depth'].values,y2_test['Nporosity'].values, 'o', markerfacecolor='blue', markeredgecolor='black', alpha=1.0, label = \"Test\")\n",
    "plt.xlabel('Depth (m)')\n",
    "plt.ylabel('Porosity (faction)')\n",
    "plt.legend()\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=0.8, wspace=0.2, hspace=0.2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\17137\\anaconda3\\envs\\tf\\lib\\site-packages\\keras\\optimizers\\optimizer_v2\\adam.py:110: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  super(Adam, self).__init__(name, **kwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7/7 [==============================] - 0s 4ms/step - loss: 0.2227 - accuracy: 0.0000e+00\n",
      "Epoch 2/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.2151 - accuracy: 0.0000e+00\n",
      "Epoch 3/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.2102 - accuracy: 0.0000e+00\n",
      "Epoch 4/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.2069 - accuracy: 0.0000e+00\n",
      "Epoch 5/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.2036 - accuracy: 0.0000e+00\n",
      "Epoch 6/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.2005 - accuracy: 0.0000e+00\n",
      "Epoch 7/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1978 - accuracy: 0.0000e+00\n",
      "Epoch 8/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1956 - accuracy: 0.0000e+00\n",
      "Epoch 9/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1938 - accuracy: 0.0000e+00\n",
      "Epoch 10/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1919 - accuracy: 0.0000e+00\n",
      "Epoch 11/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1904 - accuracy: 0.0000e+00\n",
      "Epoch 12/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1894 - accuracy: 0.0000e+00\n",
      "Epoch 13/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1882 - accuracy: 0.0000e+00\n",
      "Epoch 14/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1868 - accuracy: 0.0000e+00\n",
      "Epoch 15/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1859 - accuracy: 0.0000e+00\n",
      "Epoch 16/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1849 - accuracy: 0.0000e+00\n",
      "Epoch 17/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1842 - accuracy: 0.0000e+00\n",
      "Epoch 18/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1830 - accuracy: 0.0000e+00\n",
      "Epoch 19/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1822 - accuracy: 0.0000e+00\n",
      "Epoch 20/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1817 - accuracy: 0.0000e+00\n",
      "Epoch 21/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1807 - accuracy: 0.0000e+00\n",
      "Epoch 22/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1800 - accuracy: 0.0000e+00\n",
      "Epoch 23/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1793 - accuracy: 0.0000e+00\n",
      "Epoch 24/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1789 - accuracy: 0.0000e+00\n",
      "Epoch 25/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1781 - accuracy: 0.0000e+00\n",
      "Epoch 26/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1771 - accuracy: 0.0000e+00\n",
      "Epoch 27/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1761 - accuracy: 0.0000e+00\n",
      "Epoch 28/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1754 - accuracy: 0.0000e+00\n",
      "Epoch 29/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1747 - accuracy: 0.0000e+00\n",
      "Epoch 30/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1738 - accuracy: 0.0000e+00\n",
      "Epoch 31/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1730 - accuracy: 0.0000e+00\n",
      "Epoch 32/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1722 - accuracy: 0.0000e+00\n",
      "Epoch 33/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1716 - accuracy: 0.0000e+00\n",
      "Epoch 34/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1708 - accuracy: 0.0000e+00\n",
      "Epoch 35/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1700 - accuracy: 0.0000e+00\n",
      "Epoch 36/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1692 - accuracy: 0.0000e+00\n",
      "Epoch 37/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1684 - accuracy: 0.0000e+00\n",
      "Epoch 38/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1676 - accuracy: 0.0000e+00\n",
      "Epoch 39/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1668 - accuracy: 0.0000e+00\n",
      "Epoch 40/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1664 - accuracy: 0.0000e+00\n",
      "Epoch 41/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1653 - accuracy: 0.0000e+00\n",
      "Epoch 42/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1646 - accuracy: 0.0000e+00\n",
      "Epoch 43/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1639 - accuracy: 0.0000e+00\n",
      "Epoch 44/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1632 - accuracy: 0.0000e+00\n",
      "Epoch 45/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1624 - accuracy: 0.0000e+00\n",
      "Epoch 46/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1614 - accuracy: 0.0000e+00\n",
      "Epoch 47/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1608 - accuracy: 0.0000e+00\n",
      "Epoch 48/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1601 - accuracy: 0.0000e+00\n",
      "Epoch 49/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1598 - accuracy: 0.0000e+00\n",
      "Epoch 50/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1587 - accuracy: 0.0000e+00\n",
      "Epoch 51/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1583 - accuracy: 0.0000e+00\n",
      "Epoch 52/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1576 - accuracy: 0.0000e+00\n",
      "Epoch 53/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1566 - accuracy: 0.0000e+00\n",
      "Epoch 54/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1560 - accuracy: 0.0000e+00\n",
      "Epoch 55/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1561 - accuracy: 0.0000e+00\n",
      "Epoch 56/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1546 - accuracy: 0.0000e+00\n",
      "Epoch 57/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1539 - accuracy: 0.0000e+00\n",
      "Epoch 58/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1535 - accuracy: 0.0000e+00\n",
      "Epoch 59/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1527 - accuracy: 0.0000e+00\n",
      "Epoch 60/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1519 - accuracy: 0.0000e+00\n",
      "Epoch 61/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1513 - accuracy: 0.0000e+00\n",
      "Epoch 62/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1503 - accuracy: 0.0000e+00\n",
      "Epoch 63/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1498 - accuracy: 0.0000e+00\n",
      "Epoch 64/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1493 - accuracy: 0.0000e+00\n",
      "Epoch 65/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1493 - accuracy: 0.0000e+00\n",
      "Epoch 66/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1484 - accuracy: 0.0000e+00\n",
      "Epoch 67/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1474 - accuracy: 0.0000e+00\n",
      "Epoch 68/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1470 - accuracy: 0.0000e+00\n",
      "Epoch 69/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1462 - accuracy: 0.0000e+00\n",
      "Epoch 70/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1457 - accuracy: 0.0000e+00\n",
      "Epoch 71/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1459 - accuracy: 0.0000e+00\n",
      "Epoch 72/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1447 - accuracy: 0.0000e+00\n",
      "Epoch 73/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1436 - accuracy: 0.0000e+00\n",
      "Epoch 74/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1429 - accuracy: 0.0000e+00\n",
      "Epoch 75/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1421 - accuracy: 0.0000e+00\n",
      "Epoch 76/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1416 - accuracy: 0.0000e+00\n",
      "Epoch 77/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1409 - accuracy: 0.0000e+00\n",
      "Epoch 78/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1401 - accuracy: 0.0000e+00\n",
      "Epoch 79/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1394 - accuracy: 0.0000e+00\n",
      "Epoch 80/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1389 - accuracy: 0.0000e+00\n",
      "Epoch 81/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1386 - accuracy: 0.0000e+00\n",
      "Epoch 82/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1376 - accuracy: 0.0000e+00\n",
      "Epoch 83/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1373 - accuracy: 0.0000e+00\n",
      "Epoch 84/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1364 - accuracy: 0.0000e+00\n",
      "Epoch 85/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1357 - accuracy: 0.0000e+00\n",
      "Epoch 86/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1355 - accuracy: 0.0000e+00\n",
      "Epoch 87/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1358 - accuracy: 0.0000e+00\n",
      "Epoch 88/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1337 - accuracy: 0.0000e+00\n",
      "Epoch 89/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1330 - accuracy: 0.0000e+00\n",
      "Epoch 90/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1331 - accuracy: 0.0000e+00\n",
      "Epoch 91/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1317 - accuracy: 0.0000e+00\n",
      "Epoch 92/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1312 - accuracy: 0.0000e+00\n",
      "Epoch 93/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1306 - accuracy: 0.0000e+00\n",
      "Epoch 94/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1297 - accuracy: 0.0000e+00\n",
      "Epoch 95/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1291 - accuracy: 0.0000e+00\n",
      "Epoch 96/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1282 - accuracy: 0.0000e+00\n",
      "Epoch 97/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1272 - accuracy: 0.0000e+00\n",
      "Epoch 98/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1273 - accuracy: 0.0000e+00\n",
      "Epoch 99/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1265 - accuracy: 0.0000e+00\n",
      "Epoch 100/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1266 - accuracy: 0.0000e+00\n",
      "Epoch 101/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1245 - accuracy: 0.0000e+00\n",
      "Epoch 102/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1237 - accuracy: 0.0000e+00\n",
      "Epoch 103/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1232 - accuracy: 0.0000e+00\n",
      "Epoch 104/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1231 - accuracy: 0.0000e+00\n",
      "Epoch 105/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1218 - accuracy: 0.0000e+00\n",
      "Epoch 106/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1208 - accuracy: 0.0000e+00\n",
      "Epoch 107/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1199 - accuracy: 0.0000e+00\n",
      "Epoch 108/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1195 - accuracy: 0.0000e+00\n",
      "Epoch 109/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1189 - accuracy: 0.0000e+00\n",
      "Epoch 110/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1191 - accuracy: 0.0000e+00\n",
      "Epoch 111/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1176 - accuracy: 0.0000e+00\n",
      "Epoch 112/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1166 - accuracy: 0.0000e+00\n",
      "Epoch 113/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1168 - accuracy: 0.0000e+00\n",
      "Epoch 114/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1156 - accuracy: 0.0000e+00\n",
      "Epoch 115/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1148 - accuracy: 0.0000e+00\n",
      "Epoch 116/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1142 - accuracy: 0.0000e+00\n",
      "Epoch 117/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1135 - accuracy: 0.0000e+00\n",
      "Epoch 118/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1134 - accuracy: 0.0000e+00\n",
      "Epoch 119/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1131 - accuracy: 0.0000e+00\n",
      "Epoch 120/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1123 - accuracy: 0.0000e+00\n",
      "Epoch 121/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1116 - accuracy: 0.0000e+00\n",
      "Epoch 122/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1114 - accuracy: 0.0000e+00\n",
      "Epoch 123/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1101 - accuracy: 0.0000e+00\n",
      "Epoch 124/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1100 - accuracy: 0.0000e+00\n",
      "Epoch 125/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1091 - accuracy: 0.0000e+00\n",
      "Epoch 126/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1079 - accuracy: 0.0000e+00\n",
      "Epoch 127/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1075 - accuracy: 0.0000e+00\n",
      "Epoch 128/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1073 - accuracy: 0.0000e+00\n",
      "Epoch 129/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1072 - accuracy: 0.0000e+00\n",
      "Epoch 130/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1070 - accuracy: 0.0000e+00\n",
      "Epoch 131/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1055 - accuracy: 0.0000e+00\n",
      "Epoch 132/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1054 - accuracy: 0.0000e+00\n",
      "Epoch 133/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1043 - accuracy: 0.0000e+00\n",
      "Epoch 134/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1037 - accuracy: 0.0000e+00\n",
      "Epoch 135/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1030 - accuracy: 0.0000e+00\n",
      "Epoch 136/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1024 - accuracy: 0.0000e+00\n",
      "Epoch 137/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1025 - accuracy: 0.0000e+00\n",
      "Epoch 138/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1015 - accuracy: 0.0000e+00\n",
      "Epoch 139/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1008 - accuracy: 0.0000e+00\n",
      "Epoch 140/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1004 - accuracy: 0.0000e+00\n",
      "Epoch 141/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.1013 - accuracy: 0.0000e+00\n",
      "Epoch 142/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0994 - accuracy: 0.0000e+00\n",
      "Epoch 143/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0988 - accuracy: 0.0000e+00\n",
      "Epoch 144/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0981 - accuracy: 0.0000e+00\n",
      "Epoch 145/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0976 - accuracy: 0.0000e+00\n",
      "Epoch 146/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0970 - accuracy: 0.0000e+00\n",
      "Epoch 147/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0983 - accuracy: 0.0000e+00\n",
      "Epoch 148/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0967 - accuracy: 0.0000e+00\n",
      "Epoch 149/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0961 - accuracy: 0.0000e+00\n",
      "Epoch 150/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0948 - accuracy: 0.0000e+00\n",
      "Epoch 151/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0944 - accuracy: 0.0000e+00\n",
      "Epoch 152/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0940 - accuracy: 0.0000e+00\n",
      "Epoch 153/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0937 - accuracy: 0.0000e+00\n",
      "Epoch 154/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0935 - accuracy: 0.0000e+00\n",
      "Epoch 155/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0931 - accuracy: 0.0000e+00\n",
      "Epoch 156/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0922 - accuracy: 0.0000e+00\n",
      "Epoch 157/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0915 - accuracy: 0.0000e+00\n",
      "Epoch 158/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0909 - accuracy: 0.0000e+00\n",
      "Epoch 159/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0905 - accuracy: 0.0000e+00\n",
      "Epoch 160/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0897 - accuracy: 0.0000e+00\n",
      "Epoch 161/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0907 - accuracy: 0.0000e+00\n",
      "Epoch 162/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0891 - accuracy: 0.0000e+00\n",
      "Epoch 163/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0886 - accuracy: 0.0000e+00\n",
      "Epoch 164/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0882 - accuracy: 0.0000e+00\n",
      "Epoch 165/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0887 - accuracy: 0.0000e+00\n",
      "Epoch 166/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0873 - accuracy: 0.0000e+00\n",
      "Epoch 167/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0869 - accuracy: 0.0000e+00\n",
      "Epoch 168/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0872 - accuracy: 0.0000e+00\n",
      "Epoch 169/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0863 - accuracy: 0.0000e+00\n",
      "Epoch 170/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0856 - accuracy: 0.0000e+00\n",
      "Epoch 171/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0849 - accuracy: 0.0000e+00\n",
      "Epoch 172/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0853 - accuracy: 0.0000e+00\n",
      "Epoch 173/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0845 - accuracy: 0.0000e+00\n",
      "Epoch 174/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0833 - accuracy: 0.0000e+00\n",
      "Epoch 175/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0832 - accuracy: 0.0000e+00\n",
      "Epoch 176/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0831 - accuracy: 0.0000e+00\n",
      "Epoch 177/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0818 - accuracy: 0.0000e+00\n",
      "Epoch 178/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0815 - accuracy: 0.0000e+00\n",
      "Epoch 179/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0822 - accuracy: 0.0000e+00\n",
      "Epoch 180/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0817 - accuracy: 0.0000e+00\n",
      "Epoch 181/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0807 - accuracy: 0.0000e+00\n",
      "Epoch 182/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0811 - accuracy: 0.0000e+00\n",
      "Epoch 183/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0806 - accuracy: 0.0000e+00\n",
      "Epoch 184/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0797 - accuracy: 0.0000e+00\n",
      "Epoch 185/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0792 - accuracy: 0.0000e+00\n",
      "Epoch 186/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0793 - accuracy: 0.0000e+00\n",
      "Epoch 187/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0792 - accuracy: 0.0000e+00\n",
      "Epoch 188/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0786 - accuracy: 0.0000e+00\n",
      "Epoch 189/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0785 - accuracy: 0.0000e+00\n",
      "Epoch 190/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0783 - accuracy: 0.0000e+00\n",
      "Epoch 191/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0785 - accuracy: 0.0000e+00\n",
      "Epoch 192/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0772 - accuracy: 0.0000e+00\n",
      "Epoch 193/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0771 - accuracy: 0.0000e+00\n",
      "Epoch 194/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0770 - accuracy: 0.0000e+00\n",
      "Epoch 195/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0768 - accuracy: 0.0000e+00\n",
      "Epoch 196/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0771 - accuracy: 0.0000e+00\n",
      "Epoch 197/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0765 - accuracy: 0.0000e+00\n",
      "Epoch 198/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0769 - accuracy: 0.0000e+00\n",
      "Epoch 199/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0764 - accuracy: 0.0000e+00\n",
      "Epoch 200/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0764 - accuracy: 0.0000e+00\n",
      "Epoch 201/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0768 - accuracy: 0.0000e+00\n",
      "Epoch 202/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0753 - accuracy: 0.0000e+00\n",
      "Epoch 203/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0758 - accuracy: 0.0000e+00\n",
      "Epoch 204/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0750 - accuracy: 0.0000e+00\n",
      "Epoch 205/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0749 - accuracy: 0.0000e+00\n",
      "Epoch 206/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0748 - accuracy: 0.0000e+00\n",
      "Epoch 207/20000\n",
      "7/7 [==============================] - 0s 5ms/step - loss: 0.0748 - accuracy: 0.0000e+00\n",
      "Epoch 208/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0745 - accuracy: 0.0000e+00\n",
      "Epoch 209/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0746 - accuracy: 0.0000e+00\n",
      "Epoch 210/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0746 - accuracy: 0.0000e+00\n",
      "Epoch 211/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0744 - accuracy: 0.0000e+00\n",
      "Epoch 212/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0745 - accuracy: 0.0000e+00\n",
      "Epoch 213/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0743 - accuracy: 0.0000e+00\n",
      "Epoch 214/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0738 - accuracy: 0.0000e+00\n",
      "Epoch 215/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0741 - accuracy: 0.0000e+00\n",
      "Epoch 216/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0737 - accuracy: 0.0000e+00\n",
      "Epoch 217/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0738 - accuracy: 0.0000e+00\n",
      "Epoch 218/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0735 - accuracy: 0.0000e+00\n",
      "Epoch 219/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0733 - accuracy: 0.0000e+00\n",
      "Epoch 220/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0730 - accuracy: 0.0000e+00\n",
      "Epoch 221/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0731 - accuracy: 0.0000e+00\n",
      "Epoch 222/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0732 - accuracy: 0.0000e+00\n",
      "Epoch 223/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0731 - accuracy: 0.0000e+00\n",
      "Epoch 224/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0730 - accuracy: 0.0000e+00\n",
      "Epoch 225/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0725 - accuracy: 0.0000e+00\n",
      "Epoch 226/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0737 - accuracy: 0.0000e+00\n",
      "Epoch 227/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0736 - accuracy: 0.0000e+00\n",
      "Epoch 228/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0736 - accuracy: 0.0000e+00\n",
      "Epoch 229/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0731 - accuracy: 0.0000e+00\n",
      "Epoch 230/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0727 - accuracy: 0.0000e+00\n",
      "Epoch 231/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0722 - accuracy: 0.0000e+00\n",
      "Epoch 232/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0722 - accuracy: 0.0000e+00\n",
      "Epoch 233/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0722 - accuracy: 0.0000e+00\n",
      "Epoch 234/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0717 - accuracy: 0.0000e+00\n",
      "Epoch 235/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0723 - accuracy: 0.0000e+00\n",
      "Epoch 236/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0718 - accuracy: 0.0000e+00\n",
      "Epoch 237/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0720 - accuracy: 0.0000e+00\n",
      "Epoch 238/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0723 - accuracy: 0.0000e+00\n",
      "Epoch 239/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0716 - accuracy: 0.0000e+00\n",
      "Epoch 240/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0725 - accuracy: 0.0000e+00\n",
      "Epoch 241/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0718 - accuracy: 0.0000e+00\n",
      "Epoch 242/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0710 - accuracy: 0.0000e+00\n",
      "Epoch 243/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0720 - accuracy: 0.0000e+00\n",
      "Epoch 244/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0722 - accuracy: 0.0000e+00\n",
      "Epoch 245/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0720 - accuracy: 0.0000e+00\n",
      "Epoch 246/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0715 - accuracy: 0.0000e+00\n",
      "Epoch 247/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0708 - accuracy: 0.0000e+00\n",
      "Epoch 248/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0723 - accuracy: 0.0000e+00\n",
      "Epoch 249/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0710 - accuracy: 0.0000e+00\n",
      "Epoch 250/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0713 - accuracy: 0.0000e+00\n",
      "Epoch 251/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0715 - accuracy: 0.0000e+00\n",
      "Epoch 252/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0713 - accuracy: 0.0000e+00\n",
      "Epoch 253/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0709 - accuracy: 0.0000e+00\n",
      "Epoch 254/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0709 - accuracy: 0.0000e+00\n",
      "Epoch 255/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0710 - accuracy: 0.0000e+00\n",
      "Epoch 256/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0714 - accuracy: 0.0000e+00\n",
      "Epoch 257/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0711 - accuracy: 0.0000e+00\n",
      "Epoch 258/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0708 - accuracy: 0.0000e+00\n",
      "Epoch 259/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0706 - accuracy: 0.0000e+00\n",
      "Epoch 260/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0703 - accuracy: 0.0000e+00\n",
      "Epoch 261/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0705 - accuracy: 0.0000e+00\n",
      "Epoch 262/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0721 - accuracy: 0.0000e+00\n",
      "Epoch 263/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0704 - accuracy: 0.0000e+00\n",
      "Epoch 264/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0703 - accuracy: 0.0000e+00\n",
      "Epoch 265/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0705 - accuracy: 0.0000e+00\n",
      "Epoch 266/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0703 - accuracy: 0.0000e+00\n",
      "Epoch 267/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0702 - accuracy: 0.0000e+00\n",
      "Epoch 268/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0701 - accuracy: 0.0000e+00\n",
      "Epoch 269/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0704 - accuracy: 0.0000e+00\n",
      "Epoch 270/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0706 - accuracy: 0.0000e+00\n",
      "Epoch 271/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0698 - accuracy: 0.0000e+00\n",
      "Epoch 272/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0699 - accuracy: 0.0000e+00\n",
      "Epoch 273/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0711 - accuracy: 0.0000e+00\n",
      "Epoch 274/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0711 - accuracy: 0.0000e+00\n",
      "Epoch 275/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0713 - accuracy: 0.0000e+00\n",
      "Epoch 276/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0712 - accuracy: 0.0000e+00\n",
      "Epoch 277/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0701 - accuracy: 0.0000e+00\n",
      "Epoch 278/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0700 - accuracy: 0.0000e+00\n",
      "Epoch 279/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0707 - accuracy: 0.0000e+00\n",
      "Epoch 280/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0704 - accuracy: 0.0000e+00\n",
      "Epoch 281/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0702 - accuracy: 0.0000e+00\n",
      "Epoch 282/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0697 - accuracy: 0.0000e+00\n",
      "Epoch 283/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0704 - accuracy: 0.0000e+00\n",
      "Epoch 284/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0701 - accuracy: 0.0000e+00\n",
      "Epoch 285/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0699 - accuracy: 0.0000e+00\n",
      "Epoch 286/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0698 - accuracy: 0.0000e+00\n",
      "Epoch 287/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0705 - accuracy: 0.0000e+00\n",
      "Epoch 288/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0692 - accuracy: 0.0000e+00\n",
      "Epoch 289/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0692 - accuracy: 0.0000e+00\n",
      "Epoch 290/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0694 - accuracy: 0.0000e+00\n",
      "Epoch 291/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0696 - accuracy: 0.0000e+00\n",
      "Epoch 292/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0694 - accuracy: 0.0000e+00\n",
      "Epoch 293/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0696 - accuracy: 0.0000e+00\n",
      "Epoch 294/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0698 - accuracy: 0.0000e+00\n",
      "Epoch 295/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0689 - accuracy: 0.0000e+00\n",
      "Epoch 296/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0691 - accuracy: 0.0000e+00\n",
      "Epoch 297/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0691 - accuracy: 0.0000e+00\n",
      "Epoch 298/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0699 - accuracy: 0.0000e+00\n",
      "Epoch 299/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0699 - accuracy: 0.0000e+00\n",
      "Epoch 300/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0697 - accuracy: 0.0000e+00\n",
      "Epoch 301/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0692 - accuracy: 0.0000e+00\n",
      "Epoch 302/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0691 - accuracy: 0.0000e+00\n",
      "Epoch 303/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0690 - accuracy: 0.0000e+00\n",
      "Epoch 304/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0686 - accuracy: 0.0000e+00\n",
      "Epoch 305/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0686 - accuracy: 0.0000e+00\n",
      "Epoch 306/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0690 - accuracy: 0.0000e+00\n",
      "Epoch 307/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0682 - accuracy: 0.0000e+00\n",
      "Epoch 308/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0701 - accuracy: 0.0000e+00\n",
      "Epoch 309/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0692 - accuracy: 0.0000e+00\n",
      "Epoch 310/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0692 - accuracy: 0.0000e+00\n",
      "Epoch 311/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0687 - accuracy: 0.0000e+00\n",
      "Epoch 312/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0683 - accuracy: 0.0000e+00\n",
      "Epoch 313/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0685 - accuracy: 0.0000e+00\n",
      "Epoch 314/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0684 - accuracy: 0.0000e+00\n",
      "Epoch 315/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0691 - accuracy: 0.0000e+00\n",
      "Epoch 316/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0684 - accuracy: 0.0000e+00\n",
      "Epoch 317/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0681 - accuracy: 0.0000e+00\n",
      "Epoch 318/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0682 - accuracy: 0.0000e+00\n",
      "Epoch 319/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0681 - accuracy: 0.0000e+00\n",
      "Epoch 320/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0683 - accuracy: 0.0000e+00\n",
      "Epoch 321/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0688 - accuracy: 0.0000e+00\n",
      "Epoch 322/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0684 - accuracy: 0.0000e+00\n",
      "Epoch 323/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0683 - accuracy: 0.0000e+00\n",
      "Epoch 324/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0681 - accuracy: 0.0000e+00\n",
      "Epoch 325/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0679 - accuracy: 0.0000e+00\n",
      "Epoch 326/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0680 - accuracy: 0.0000e+00\n",
      "Epoch 327/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0677 - accuracy: 0.0000e+00\n",
      "Epoch 328/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0680 - accuracy: 0.0000e+00\n",
      "Epoch 329/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0680 - accuracy: 0.0000e+00\n",
      "Epoch 330/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0682 - accuracy: 0.0000e+00\n",
      "Epoch 331/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0682 - accuracy: 0.0000e+00\n",
      "Epoch 332/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0684 - accuracy: 0.0000e+00\n",
      "Epoch 333/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0686 - accuracy: 0.0000e+00\n",
      "Epoch 334/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0678 - accuracy: 0.0000e+00\n",
      "Epoch 335/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0676 - accuracy: 0.0000e+00\n",
      "Epoch 336/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0678 - accuracy: 0.0000e+00\n",
      "Epoch 337/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0674 - accuracy: 0.0000e+00\n",
      "Epoch 338/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0674 - accuracy: 0.0000e+00\n",
      "Epoch 339/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0680 - accuracy: 0.0000e+00\n",
      "Epoch 340/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0676 - accuracy: 0.0000e+00\n",
      "Epoch 341/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0675 - accuracy: 0.0000e+00\n",
      "Epoch 342/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0677 - accuracy: 0.0000e+00\n",
      "Epoch 343/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0694 - accuracy: 0.0000e+00\n",
      "Epoch 344/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0684 - accuracy: 0.0000e+00\n",
      "Epoch 345/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0672 - accuracy: 0.0000e+00\n",
      "Epoch 346/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0678 - accuracy: 0.0000e+00\n",
      "Epoch 347/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0677 - accuracy: 0.0000e+00\n",
      "Epoch 348/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0674 - accuracy: 0.0000e+00\n",
      "Epoch 349/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0672 - accuracy: 0.0000e+00\n",
      "Epoch 350/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0672 - accuracy: 0.0000e+00\n",
      "Epoch 351/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0672 - accuracy: 0.0000e+00\n",
      "Epoch 352/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0674 - accuracy: 0.0000e+00\n",
      "Epoch 353/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0671 - accuracy: 0.0000e+00\n",
      "Epoch 354/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0672 - accuracy: 0.0000e+00\n",
      "Epoch 355/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0668 - accuracy: 0.0000e+00\n",
      "Epoch 356/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0667 - accuracy: 0.0000e+00\n",
      "Epoch 357/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0670 - accuracy: 0.0000e+00\n",
      "Epoch 358/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0676 - accuracy: 0.0000e+00\n",
      "Epoch 359/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0673 - accuracy: 0.0000e+00\n",
      "Epoch 360/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0670 - accuracy: 0.0000e+00\n",
      "Epoch 361/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0670 - accuracy: 0.0000e+00\n",
      "Epoch 362/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0669 - accuracy: 0.0000e+00\n",
      "Epoch 363/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0667 - accuracy: 0.0000e+00\n",
      "Epoch 364/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0674 - accuracy: 0.0000e+00\n",
      "Epoch 365/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0674 - accuracy: 0.0000e+00\n",
      "Epoch 366/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0682 - accuracy: 0.0000e+00\n",
      "Epoch 367/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0684 - accuracy: 0.0000e+00\n",
      "Epoch 368/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0671 - accuracy: 0.0000e+00\n",
      "Epoch 369/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0669 - accuracy: 0.0000e+00\n",
      "Epoch 370/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0666 - accuracy: 0.0000e+00\n",
      "Epoch 371/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0667 - accuracy: 0.0000e+00\n",
      "Epoch 372/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0666 - accuracy: 0.0000e+00\n",
      "Epoch 373/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0670 - accuracy: 0.0000e+00\n",
      "Epoch 374/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0669 - accuracy: 0.0000e+00\n",
      "Epoch 375/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0669 - accuracy: 0.0000e+00\n",
      "Epoch 376/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0673 - accuracy: 0.0000e+00\n",
      "Epoch 377/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0672 - accuracy: 0.0000e+00\n",
      "Epoch 378/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0669 - accuracy: 0.0000e+00\n",
      "Epoch 379/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0673 - accuracy: 0.0000e+00\n",
      "Epoch 380/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0666 - accuracy: 0.0000e+00\n",
      "Epoch 381/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0665 - accuracy: 0.0000e+00\n",
      "Epoch 382/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0674 - accuracy: 0.0000e+00\n",
      "Epoch 383/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0667 - accuracy: 0.0000e+00\n",
      "Epoch 384/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0662 - accuracy: 0.0000e+00\n",
      "Epoch 385/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0662 - accuracy: 0.0000e+00\n",
      "Epoch 386/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0661 - accuracy: 0.0000e+00\n",
      "Epoch 387/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0661 - accuracy: 0.0000e+00\n",
      "Epoch 388/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0658 - accuracy: 0.0000e+00\n",
      "Epoch 389/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0666 - accuracy: 0.0000e+00\n",
      "Epoch 390/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0661 - accuracy: 0.0000e+00\n",
      "Epoch 391/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0666 - accuracy: 0.0000e+00\n",
      "Epoch 392/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0660 - accuracy: 0.0000e+00\n",
      "Epoch 393/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0670 - accuracy: 0.0000e+00\n",
      "Epoch 394/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0654 - accuracy: 0.0000e+00\n",
      "Epoch 395/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0660 - accuracy: 0.0000e+00\n",
      "Epoch 396/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0658 - accuracy: 0.0000e+00\n",
      "Epoch 397/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0655 - accuracy: 0.0000e+00\n",
      "Epoch 398/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0662 - accuracy: 0.0000e+00\n",
      "Epoch 399/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0663 - accuracy: 0.0000e+00\n",
      "Epoch 400/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0665 - accuracy: 0.0000e+00\n",
      "Epoch 401/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0656 - accuracy: 0.0000e+00\n",
      "Epoch 402/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0656 - accuracy: 0.0000e+00\n",
      "Epoch 403/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0653 - accuracy: 0.0000e+00\n",
      "Epoch 404/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0661 - accuracy: 0.0000e+00\n",
      "Epoch 405/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0653 - accuracy: 0.0000e+00\n",
      "Epoch 406/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0655 - accuracy: 0.0000e+00\n",
      "Epoch 407/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0655 - accuracy: 0.0000e+00\n",
      "Epoch 408/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0657 - accuracy: 0.0000e+00\n",
      "Epoch 409/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0659 - accuracy: 0.0000e+00\n",
      "Epoch 410/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0654 - accuracy: 0.0000e+00\n",
      "Epoch 411/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0655 - accuracy: 0.0000e+00\n",
      "Epoch 412/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0652 - accuracy: 0.0000e+00\n",
      "Epoch 413/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0652 - accuracy: 0.0000e+00\n",
      "Epoch 414/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0653 - accuracy: 0.0000e+00\n",
      "Epoch 415/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0653 - accuracy: 0.0000e+00\n",
      "Epoch 416/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0652 - accuracy: 0.0000e+00\n",
      "Epoch 417/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0652 - accuracy: 0.0000e+00\n",
      "Epoch 418/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0647 - accuracy: 0.0000e+00\n",
      "Epoch 419/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0651 - accuracy: 0.0000e+00\n",
      "Epoch 420/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0650 - accuracy: 0.0000e+00\n",
      "Epoch 421/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0650 - accuracy: 0.0000e+00\n",
      "Epoch 422/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0648 - accuracy: 0.0000e+00\n",
      "Epoch 423/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0648 - accuracy: 0.0000e+00\n",
      "Epoch 424/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0648 - accuracy: 0.0000e+00\n",
      "Epoch 425/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0649 - accuracy: 0.0000e+00\n",
      "Epoch 426/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0654 - accuracy: 0.0000e+00\n",
      "Epoch 427/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0647 - accuracy: 0.0000e+00\n",
      "Epoch 428/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0648 - accuracy: 0.0000e+00\n",
      "Epoch 429/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0649 - accuracy: 0.0000e+00\n",
      "Epoch 430/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0653 - accuracy: 0.0000e+00\n",
      "Epoch 431/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0649 - accuracy: 0.0000e+00\n",
      "Epoch 432/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0650 - accuracy: 0.0000e+00\n",
      "Epoch 433/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0645 - accuracy: 0.0000e+00\n",
      "Epoch 434/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0647 - accuracy: 0.0000e+00\n",
      "Epoch 435/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0645 - accuracy: 0.0000e+00\n",
      "Epoch 436/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0647 - accuracy: 0.0000e+00\n",
      "Epoch 437/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0647 - accuracy: 0.0000e+00\n",
      "Epoch 438/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0644 - accuracy: 0.0000e+00\n",
      "Epoch 439/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0649 - accuracy: 0.0000e+00\n",
      "Epoch 440/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0643 - accuracy: 0.0000e+00\n",
      "Epoch 441/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0645 - accuracy: 0.0000e+00\n",
      "Epoch 442/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0648 - accuracy: 0.0000e+00\n",
      "Epoch 443/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0657 - accuracy: 0.0000e+00\n",
      "Epoch 444/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0654 - accuracy: 0.0000e+00\n",
      "Epoch 445/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0649 - accuracy: 0.0000e+00\n",
      "Epoch 446/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0651 - accuracy: 0.0000e+00\n",
      "Epoch 447/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0644 - accuracy: 0.0000e+00\n",
      "Epoch 448/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0644 - accuracy: 0.0000e+00\n",
      "Epoch 449/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0644 - accuracy: 0.0000e+00\n",
      "Epoch 450/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0641 - accuracy: 0.0000e+00\n",
      "Epoch 451/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0641 - accuracy: 0.0000e+00\n",
      "Epoch 452/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0641 - accuracy: 0.0000e+00\n",
      "Epoch 453/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0644 - accuracy: 0.0000e+00\n",
      "Epoch 454/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0639 - accuracy: 0.0000e+00\n",
      "Epoch 455/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0638 - accuracy: 0.0000e+00\n",
      "Epoch 456/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0639 - accuracy: 0.0000e+00\n",
      "Epoch 457/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0640 - accuracy: 0.0000e+00\n",
      "Epoch 458/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0663 - accuracy: 0.0000e+00\n",
      "Epoch 459/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0639 - accuracy: 0.0000e+00\n",
      "Epoch 460/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0650 - accuracy: 0.0000e+00\n",
      "Epoch 461/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0638 - accuracy: 0.0000e+00\n",
      "Epoch 462/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0639 - accuracy: 0.0000e+00\n",
      "Epoch 463/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0637 - accuracy: 0.0000e+00\n",
      "Epoch 464/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0634 - accuracy: 0.0000e+00\n",
      "Epoch 465/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0635 - accuracy: 0.0000e+00\n",
      "Epoch 466/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0636 - accuracy: 0.0000e+00\n",
      "Epoch 467/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0636 - accuracy: 0.0000e+00\n",
      "Epoch 468/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0637 - accuracy: 0.0000e+00\n",
      "Epoch 469/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0634 - accuracy: 0.0000e+00\n",
      "Epoch 470/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0638 - accuracy: 0.0000e+00\n",
      "Epoch 471/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0637 - accuracy: 0.0000e+00\n",
      "Epoch 472/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0636 - accuracy: 0.0000e+00\n",
      "Epoch 473/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0633 - accuracy: 0.0000e+00\n",
      "Epoch 474/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0636 - accuracy: 0.0000e+00\n",
      "Epoch 475/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0635 - accuracy: 0.0000e+00\n",
      "Epoch 476/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0635 - accuracy: 0.0000e+00\n",
      "Epoch 477/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0634 - accuracy: 0.0000e+00\n",
      "Epoch 478/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0634 - accuracy: 0.0000e+00\n",
      "Epoch 479/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0632 - accuracy: 0.0000e+00\n",
      "Epoch 480/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0630 - accuracy: 0.0000e+00\n",
      "Epoch 481/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0633 - accuracy: 0.0000e+00\n",
      "Epoch 482/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0640 - accuracy: 0.0000e+00\n",
      "Epoch 483/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0636 - accuracy: 0.0000e+00\n",
      "Epoch 484/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0636 - accuracy: 0.0000e+00\n",
      "Epoch 485/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0637 - accuracy: 0.0000e+00\n",
      "Epoch 486/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0628 - accuracy: 0.0000e+00\n",
      "Epoch 487/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0631 - accuracy: 0.0000e+00\n",
      "Epoch 488/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0627 - accuracy: 0.0000e+00\n",
      "Epoch 489/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0630 - accuracy: 0.0000e+00\n",
      "Epoch 490/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0630 - accuracy: 0.0000e+00\n",
      "Epoch 491/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0630 - accuracy: 0.0000e+00\n",
      "Epoch 492/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0634 - accuracy: 0.0000e+00\n",
      "Epoch 493/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0634 - accuracy: 0.0000e+00\n",
      "Epoch 494/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0633 - accuracy: 0.0000e+00\n",
      "Epoch 495/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0628 - accuracy: 0.0000e+00\n",
      "Epoch 496/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0626 - accuracy: 0.0000e+00\n",
      "Epoch 497/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0626 - accuracy: 0.0000e+00\n",
      "Epoch 498/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0624 - accuracy: 0.0000e+00\n",
      "Epoch 499/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0628 - accuracy: 0.0000e+00\n",
      "Epoch 500/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0631 - accuracy: 0.0000e+00\n",
      "Epoch 501/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0629 - accuracy: 0.0000e+00\n",
      "Epoch 502/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0626 - accuracy: 0.0000e+00\n",
      "Epoch 503/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0627 - accuracy: 0.0000e+00\n",
      "Epoch 504/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0628 - accuracy: 0.0000e+00\n",
      "Epoch 505/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0623 - accuracy: 0.0000e+00\n",
      "Epoch 506/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0628 - accuracy: 0.0000e+00\n",
      "Epoch 507/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0626 - accuracy: 0.0000e+00\n",
      "Epoch 508/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0622 - accuracy: 0.0000e+00\n",
      "Epoch 509/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0625 - accuracy: 0.0000e+00\n",
      "Epoch 510/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0620 - accuracy: 0.0000e+00\n",
      "Epoch 511/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0623 - accuracy: 0.0000e+00\n",
      "Epoch 512/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0621 - accuracy: 0.0000e+00\n",
      "Epoch 513/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0622 - accuracy: 0.0000e+00\n",
      "Epoch 514/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0628 - accuracy: 0.0000e+00\n",
      "Epoch 515/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0625 - accuracy: 0.0000e+00\n",
      "Epoch 516/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0625 - accuracy: 0.0000e+00\n",
      "Epoch 517/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0627 - accuracy: 0.0000e+00\n",
      "Epoch 518/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0624 - accuracy: 0.0000e+00\n",
      "Epoch 519/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0624 - accuracy: 0.0000e+00\n",
      "Epoch 520/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0623 - accuracy: 0.0000e+00\n",
      "Epoch 521/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0621 - accuracy: 0.0000e+00\n",
      "Epoch 522/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0621 - accuracy: 0.0000e+00\n",
      "Epoch 523/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0627 - accuracy: 0.0000e+00\n",
      "Epoch 524/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0620 - accuracy: 0.0000e+00\n",
      "Epoch 525/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0622 - accuracy: 0.0000e+00\n",
      "Epoch 526/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0626 - accuracy: 0.0000e+00\n",
      "Epoch 527/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0618 - accuracy: 0.0000e+00\n",
      "Epoch 528/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0615 - accuracy: 0.0000e+00\n",
      "Epoch 529/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0627 - accuracy: 0.0000e+00\n",
      "Epoch 530/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0617 - accuracy: 0.0000e+00\n",
      "Epoch 531/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0620 - accuracy: 0.0000e+00\n",
      "Epoch 532/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0614 - accuracy: 0.0000e+00\n",
      "Epoch 533/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0614 - accuracy: 0.0000e+00\n",
      "Epoch 534/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0616 - accuracy: 0.0000e+00\n",
      "Epoch 535/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0619 - accuracy: 0.0000e+00\n",
      "Epoch 536/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0614 - accuracy: 0.0000e+00\n",
      "Epoch 537/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0611 - accuracy: 0.0000e+00\n",
      "Epoch 538/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0613 - accuracy: 0.0000e+00\n",
      "Epoch 539/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0611 - accuracy: 0.0000e+00\n",
      "Epoch 540/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0609 - accuracy: 0.0000e+00\n",
      "Epoch 541/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0613 - accuracy: 0.0000e+00\n",
      "Epoch 542/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0616 - accuracy: 0.0000e+00\n",
      "Epoch 543/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0612 - accuracy: 0.0000e+00\n",
      "Epoch 544/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0612 - accuracy: 0.0000e+00\n",
      "Epoch 545/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0615 - accuracy: 0.0000e+00\n",
      "Epoch 546/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0608 - accuracy: 0.0000e+00\n",
      "Epoch 547/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0612 - accuracy: 0.0000e+00\n",
      "Epoch 548/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0616 - accuracy: 0.0000e+00\n",
      "Epoch 549/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0618 - accuracy: 0.0000e+00\n",
      "Epoch 550/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0609 - accuracy: 0.0000e+00\n",
      "Epoch 551/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0607 - accuracy: 0.0000e+00\n",
      "Epoch 552/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0610 - accuracy: 0.0000e+00\n",
      "Epoch 553/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0608 - accuracy: 0.0000e+00\n",
      "Epoch 554/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0620 - accuracy: 0.0000e+00\n",
      "Epoch 555/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0610 - accuracy: 0.0000e+00\n",
      "Epoch 556/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0607 - accuracy: 0.0000e+00\n",
      "Epoch 557/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0606 - accuracy: 0.0000e+00\n",
      "Epoch 558/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0606 - accuracy: 0.0000e+00\n",
      "Epoch 559/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0613 - accuracy: 0.0000e+00\n",
      "Epoch 560/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0610 - accuracy: 0.0000e+00\n",
      "Epoch 561/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0607 - accuracy: 0.0000e+00\n",
      "Epoch 562/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0613 - accuracy: 0.0000e+00\n",
      "Epoch 563/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0605 - accuracy: 0.0000e+00\n",
      "Epoch 564/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0623 - accuracy: 0.0000e+00\n",
      "Epoch 565/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0609 - accuracy: 0.0000e+00\n",
      "Epoch 566/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0610 - accuracy: 0.0000e+00\n",
      "Epoch 567/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0608 - accuracy: 0.0000e+00\n",
      "Epoch 568/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0612 - accuracy: 0.0000e+00\n",
      "Epoch 569/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0609 - accuracy: 0.0000e+00\n",
      "Epoch 570/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0600 - accuracy: 0.0000e+00\n",
      "Epoch 571/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0608 - accuracy: 0.0000e+00\n",
      "Epoch 572/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0602 - accuracy: 0.0000e+00\n",
      "Epoch 573/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0613 - accuracy: 0.0000e+00\n",
      "Epoch 574/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0598 - accuracy: 0.0000e+00\n",
      "Epoch 575/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0602 - accuracy: 0.0000e+00\n",
      "Epoch 576/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0604 - accuracy: 0.0000e+00\n",
      "Epoch 577/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0601 - accuracy: 0.0000e+00\n",
      "Epoch 578/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0603 - accuracy: 0.0000e+00\n",
      "Epoch 579/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0597 - accuracy: 0.0000e+00\n",
      "Epoch 580/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0598 - accuracy: 0.0000e+00\n",
      "Epoch 581/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0599 - accuracy: 0.0000e+00\n",
      "Epoch 582/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0597 - accuracy: 0.0000e+00\n",
      "Epoch 583/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0594 - accuracy: 0.0000e+00\n",
      "Epoch 584/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0599 - accuracy: 0.0000e+00\n",
      "Epoch 585/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0597 - accuracy: 0.0000e+00\n",
      "Epoch 586/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0595 - accuracy: 0.0000e+00\n",
      "Epoch 587/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0597 - accuracy: 0.0000e+00\n",
      "Epoch 588/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0596 - accuracy: 0.0000e+00\n",
      "Epoch 589/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0597 - accuracy: 0.0000e+00\n",
      "Epoch 590/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0597 - accuracy: 0.0000e+00\n",
      "Epoch 591/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0601 - accuracy: 0.0000e+00\n",
      "Epoch 592/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0593 - accuracy: 0.0000e+00\n",
      "Epoch 593/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0596 - accuracy: 0.0000e+00\n",
      "Epoch 594/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0601 - accuracy: 0.0000e+00\n",
      "Epoch 595/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0598 - accuracy: 0.0000e+00\n",
      "Epoch 596/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0594 - accuracy: 0.0000e+00\n",
      "Epoch 597/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0599 - accuracy: 0.0000e+00\n",
      "Epoch 598/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0590 - accuracy: 0.0000e+00\n",
      "Epoch 599/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0594 - accuracy: 0.0000e+00\n",
      "Epoch 600/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0597 - accuracy: 0.0000e+00\n",
      "Epoch 601/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0598 - accuracy: 0.0000e+00\n",
      "Epoch 602/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0596 - accuracy: 0.0000e+00\n",
      "Epoch 603/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0597 - accuracy: 0.0000e+00\n",
      "Epoch 604/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0594 - accuracy: 0.0000e+00\n",
      "Epoch 605/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0594 - accuracy: 0.0000e+00\n",
      "Epoch 606/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0592 - accuracy: 0.0000e+00\n",
      "Epoch 607/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0593 - accuracy: 0.0000e+00\n",
      "Epoch 608/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0593 - accuracy: 0.0000e+00\n",
      "Epoch 609/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0594 - accuracy: 0.0000e+00\n",
      "Epoch 610/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0591 - accuracy: 0.0000e+00\n",
      "Epoch 611/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0589 - accuracy: 0.0000e+00\n",
      "Epoch 612/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0589 - accuracy: 0.0000e+00\n",
      "Epoch 613/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0586 - accuracy: 0.0000e+00\n",
      "Epoch 614/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0588 - accuracy: 0.0000e+00\n",
      "Epoch 615/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0588 - accuracy: 0.0000e+00\n",
      "Epoch 616/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0585 - accuracy: 0.0000e+00\n",
      "Epoch 617/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0590 - accuracy: 0.0000e+00\n",
      "Epoch 618/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0590 - accuracy: 0.0000e+00\n",
      "Epoch 619/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0587 - accuracy: 0.0000e+00\n",
      "Epoch 620/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0586 - accuracy: 0.0000e+00\n",
      "Epoch 621/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0588 - accuracy: 0.0000e+00\n",
      "Epoch 622/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0588 - accuracy: 0.0000e+00\n",
      "Epoch 623/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0590 - accuracy: 0.0000e+00\n",
      "Epoch 624/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0589 - accuracy: 0.0000e+00\n",
      "Epoch 625/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0591 - accuracy: 0.0000e+00\n",
      "Epoch 626/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0586 - accuracy: 0.0000e+00\n",
      "Epoch 627/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0582 - accuracy: 0.0000e+00\n",
      "Epoch 628/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0585 - accuracy: 0.0000e+00\n",
      "Epoch 629/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0582 - accuracy: 0.0000e+00\n",
      "Epoch 630/20000\n",
      "7/7 [==============================] - 0s 3ms/step - loss: 0.0583 - accuracy: 0.0000e+00\n",
      "Epoch 631/20000\n",
      "7/7 [==============================] - 0s 4ms/step - loss: 0.0582 - accuracy: 0.0000e+00\n",
      "Epoch 632/20000\n"
     ]
    }
   ],
   "source": [
    "model_2 = Sequential([\n",
    "    Dense(100, activation='linear', input_shape=(1,)),                  # input layer\n",
    "    Dense(50, activation='relu'),\n",
    "    Dense(50, activation='relu'),\n",
    "    Dense(50, activation='relu'), \n",
    "#     Dense(20, activation='relu'),                                    # uncomment these to add hidden layers\n",
    "#     Dense(20, activation='relu'),\n",
    "#     Dense(20, activation='relu'),\n",
    "#     Dense(20, activation='relu'),\n",
    "    Dense(1, activation='tanh'),                                     # output layer\n",
    "])\n",
    "\n",
    "\n",
    "adam = Adam(learning_rate=0.0001) # adam optimizer\n",
    "#sgd = keras.optimizers.SGD(lr=0.001, momentum=0.0, decay = 0.0, nesterov=False)  # stochastic gradient descent\n",
    "\n",
    "# Compile the Machine\n",
    "model_2.compile(optimizer=adam,loss='mse',metrics=['accuracy'])\n",
    "\n",
    "# Train the Network\n",
    "model_2.fit(X2_train['norm_Depth'].values, y2_train['norm_Nporosity'].values,\n",
    "    batch_size=5, epochs=20000)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(norm_depth_bins).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_norm_Nporsity = model_2(tf.convert_to_tensor(norm_depth_bins.reshape([-1,1]))).numpy().flatten() # predict with our ANN\n",
    "pred_Nporosity = ((pred_norm_Nporsity + 1)/2*(Npor_max - Npor_min)+Npor_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplot(1,1,1)\n",
    "plt.plot(depth_bins,pred_Nporosity,'black',linewidth=2)\n",
    "plt.plot(X2_train['Depth'].values,y2_train['Nporosity'].values, 'o', markerfacecolor='red', markeredgecolor='black', alpha=1.0, label = \"Train\")\n",
    "plt.plot(X2_test['Depth'].values,y2_test['Nporosity'].values, 'o', markerfacecolor='blue', markeredgecolor='black', alpha=1.0, label = \"Test\")\n",
    "plt.xlabel('Depth (m)')\n",
    "plt.ylabel('Porosity (faction)')\n",
    "plt.legend()\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=0.8, wspace=0.2, hspace=0.2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Design the neural network\n",
    "model_3 = Sequential([\n",
    "    Dense(100, activation='linear', input_shape=(1,)),                  # input layer\n",
    "    Dense(50, activation='relu'),\n",
    "#     Dense(50, activation='relu'),\n",
    "#     Dense(50, activation='relu'), \n",
    "#     Dense(20, activation='relu'),                                    # uncomment these to add hidden layers\n",
    "#     Dense(20, activation='relu'),\n",
    "#     Dense(20, activation='relu'),\n",
    "#     Dense(20, activation='relu'),\n",
    "    Dense(1, activation='linear'),                                     # output layer\n",
    "])\n",
    "\n",
    "adam = Adam(0.0001,0.95) # adam optimizer\n",
    "#sgd = keras.optimizers.SGD(lr=0.001, momentum=0.0, decay = 0.0, nesterov=False)  # stochastic gradient descent\n",
    "\n",
    "# Compile the Machine\n",
    "model_3.compile(optimizer=adam,loss='mse',metrics=['accuracy'])\n",
    "\n",
    "# Train the Network\n",
    "model_3.fit(X2_train['norm_Depth'].values, y2_train['norm_Nporosity'].values,\n",
    "    batch_size=5, epochs=20000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_norm_Nporsity = model_3(tf.convert_to_tensor(norm_depth_bins.reshape([-1,1]))).numpy().flatten() # predict with our ANN\n",
    "pred_Nporosity = ((pred_norm_Nporsity + 1)/2*(Npor_max - Npor_min)+Npor_min)\n",
    "plt.subplot(1,1,1)\n",
    "plt.plot(depth_bins,pred_Nporosity,'black',linewidth=2)\n",
    "plt.plot(X2_train['Depth'].values,y2_train['Nporosity'].values, 'o', markerfacecolor='red', markeredgecolor='black', alpha=1.0, label = \"Train\")\n",
    "plt.plot(X2_test['Depth'].values,y2_test['Nporosity'].values, 'o', markerfacecolor='blue', markeredgecolor='black', alpha=1.0, label = \"Test\")\n",
    "plt.xlabel('Depth (m)')\n",
    "plt.ylabel('Porosity (faction)')\n",
    "plt.legend()\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=0.8, wspace=0.2, hspace=0.2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluation of the Model\n",
    "\n",
    "For my specified artificial neural network design and optimization parameters I have a very flexible model to fit the data.\n",
    "\n",
    "* artificial neural networks live up to their designation as **Universal Function Approximators**\n",
    "\n",
    "Let's check the training curve, loss functions for our model over training and testing datasets.\n",
    "\n",
    "* **square loss** ($L_2$ loss) is the:\n",
    "\n",
    "\\begin{equation}\n",
    "L_2 = \\sum_{\\bf{u}_{\\alpha} \\in AOI} \\left(y(\\bf{u}_{\\alpha}) - \\hat{f}(x_1(\\bf{u}_{\\alpha}),\\ldots,x_m(\\bf{u}_{\\alpha})\\right)\n",
    "\\end{equation}\n",
    "\n",
    "* this is a measure of the inaccuracy over the available data\n",
    "\n",
    "We can see the progress of the model over epochs in reduction of training and testing error.\n",
    "\n",
    "* we can observe that the model matches the training data after about 200 epochs, but continues to improve up the 1,000 epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the Loss vs. Training Epoch \n",
    "plt.subplot(1,1,1)\n",
    "plt.plot(hist_2.history['loss'])\n",
    "plt.plot(hist_2.history['val_loss'])\n",
    "plt.title('Loss function of Artificial Neural Net Example #2')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper right')\n",
    "plt.ylim(0,0.4)\n",
    "plt.grid()\n",
    "plt.tight_layout()\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=0.8, wspace=0.2, hspace=0.2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some Observations\n",
    "\n",
    "We performed a set of experiments and made the following observations that may help you experiment with the design and training of this artificial neural network. Each machine was trained over 1000 epochs with a batch size of 5.\n",
    " \n",
    "For a 1 $\\times$ 100 $\\times$ 100 $\\times$ 1 neural network:\n",
    "* Learning Rate of 0.001 still converging at 1000 epochs, missing some features\n",
    "* Learning Rate of 0.1 - stuck in a local minum as a step function\n",
    "\n",
    "For a 1 $\\times$ 500 $\\times$ 500 $\\times$ 1 neural network:\n",
    "* Learning Rate of 0.01 - 0.001 for a close fit to training data\n",
    "* Learning Rate of 0.1 - stuck in a local minimum as a line\n",
    "* Learning Rate of $\\le$ 0.0001 still converging at 1000 epochs, missing some features\n",
    "\n",
    "For a 1 $\\times$ 500 $\\times$ 500 $\\times$ 500 $\\times$ 1 neural network:\n",
    "* Learning Rate of 0.01 - 0.001 for a close fit to training data\n",
    "* Learning Rate of 0.1 - stuck as a line\n",
    "* Learning Rate of $\\le$ 0.0001 still converging at 1000 epochs, missing some features\n",
    "\n",
    "#### Visualizing the Neural Net\n",
    "\n",
    "There are some methods available to interogate the artificial neural net.\n",
    "\n",
    "* neural net summary\n",
    "\n",
    "* weights\n",
    "\n",
    "Here's the summary from our neural net.  It lists by layers the number of nodes and number of parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_2.summary()                                      # artificial neural network design and number of parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also see the actual trained weights for each node in each layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for layer in model_2.layers:                            # weights for the trained artificial neural network\n",
    "    g = layer.get_config()\n",
    "    h = layer.get_weights()\n",
    "    print(g)\n",
    "    print(h)\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can observe the weights and bias terms associate with our neural network.\n",
    "\n",
    "#### Comments\n",
    "\n",
    "This was a basic demonstration of artificial neural networks. \n",
    "\n",
    "The Texas Center for Geostatistics has many other demonstrations on the basics of working with DataFrames, ndarrays, univariate statistics, plotting data, declustering, data transformations, trend modeling and many other workflows available [here](https://github.com/GeostatsGuy/PythonNumericalDemos), along with a package for geostatistics in Python called [GeostatsPy](https://github.com/GeostatsGuy/GeostatsPy). \n",
    "  \n",
    "We hope this was helpful,\n",
    "\n",
    "*Michael* and *Honggeun*\n",
    "\n",
    "***\n",
    "\n",
    "#### More on Michael Pyrcz and the Texas Center for Data Analytics and Geostatistics:\n",
    "\n",
    "### Michael Pyrcz, Associate Professor, University of Texas at Austin \n",
    "*Novel Data Analytics, Geostatistics and Machine Learning Subsurface Solutions*\n",
    "\n",
    "With over 17 years of experience in subsurface consulting, research and development, Michael has returned to academia driven by his passion for teaching and enthusiasm for enhancing engineers' and geoscientists' impact in subsurface resource development. \n",
    "\n",
    "For more about Michael check out these links:\n",
    "\n",
    "#### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)\n",
    "\n",
    "#### Want to Work Together?\n",
    "\n",
    "I hope this content is helpful to those that want to learn more about subsurface modeling, data analytics and machine learning. Students and working professionals are welcome to participate.\n",
    "\n",
    "* Want to invite me to visit your company for training, mentoring, project review, workflow design and / or consulting? I'd be happy to drop by and work with you! \n",
    "\n",
    "* Interested in partnering, supporting my graduate student research or my Subsurface Data Analytics and Machine Learning consortium (co-PIs including Profs. Foster, Torres-Verdin and van Oort)? My research combines data analytics, stochastic modeling and machine learning theory with practice to develop novel methods and workflows to add value. We are solving challenging subsurface problems!\n",
    "\n",
    "* I can be reached at mpyrcz@austin.utexas.edu.\n",
    "\n",
    "I'm always happy to discuss,\n",
    "\n",
    "*Michael*\n",
    "\n",
    "Michael Pyrcz, Ph.D., P.Eng. Associate Professor The Hildebrand Department of Petroleum and Geosystems Engineering, Bureau of Economic Geology, The Jackson School of Geosciences, The University of Texas at Austin\n",
    "\n",
    "#### More Resources Available at: [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf",
   "language": "python",
   "name": "tf"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
